const isNewProgress100 = req.body.percentCompleted !== undefined && parseInt(req.body.percentCompleted) === 100;
const isNewProgress0 = req.body.percentCompleted !== undefined && parseInt(req.body.percentCompleted) === 0;

const updateTaskStatus = async (req, res, next) => {
  try {
    req.body.updatedAt = Math.round(new Date().getTime() / 1000);
    let userStatusUpdate;
    const taskId = req.params.id;
    const { userStatusFlag } = req.query;
    const status = req.body?.status;
    const { id: userId, username } = req.userData;
    const task = await tasks.fetchSelfTask(taskId, userId);

    if (task.taskNotFound) return res.boom.notFound("Task doesn't exist");
    if (task.notAssignedToYou) return res.boom.forbidden("This task is not assigned to you");
    if (TASK_STATUS.BACKLOG === status) {
      return res.boom.forbidden("Status cannot be updated. Please contact admin.");
    }
    if (userStatusFlag) {
      if (task.taskData.status === TASK_STATUS.DONE) {
        return res.boom.forbidden("Status cannot be updated. Please contact admin.");
      }
      if (status) {
        const isCurrentTaskStatusInProgress = task.taskData.status === TASK_STATUS.IN_PROGRESS;
        const isCurrentTaskStatusBlock = task.taskData.status === TASK_STATUS.BLOCKED;
        const isNewTaskStatusInProgress = status === TASK_STATUS.IN_PROGRESS;
        const isNewTaskStatusBlock = status === TASK_STATUS.BLOCKED;
        const isCurrProgress100 = Number.parseInt(task.taskData.percentCompleted || 0) === 100;
        const isCurrProgress0 = Number.parseInt(task.taskData.percentCompleted || 0) === 0;
        const isNewProgress100 = !!req.body.percentCompleted && Number.parseInt(req.body.percentCompleted) === 100;
        const isNewProgress0 =
          req.body.percentCompleted !== undefined && Number.parseInt(req.body.percentCompleted) === 0;

        if (
          !isCurrProgress100 &&
          !isNewProgress100 &&
          (isCurrentTaskStatusBlock || isCurrentTaskStatusInProgress) &&
          !isNewTaskStatusBlock &&
          !isNewTaskStatusInProgress
        ) {
          return res.boom.badRequest(
            `The status of task can not be changed from ${
              isCurrentTaskStatusInProgress ? "In progress" : "Blocked"
            } until progress of task is not 100%.`
          );
        }
        if (isNewTaskStatusInProgress && !isCurrentTaskStatusBlock && !isCurrProgress0 && !isNewProgress0) {
          return res.boom.badRequest(
            "The status of task can not be changed to In progress until progress of task is not 0%."
          );
        }
      }
    } else {
      if (task.taskData.status === TASK_STATUS.VERIFIED || TASK_STATUS.MERGED === status) {
        return res.boom.forbidden("Status cannot be updated. Please contact admin.");
      }
      if (task.taskData.status === TASK_STATUS.COMPLETED && req.body.percentCompleted < 100) {
        if (status === TASK_STATUS.COMPLETED || !status) {
          return res.boom.badRequest("Task percentCompleted can't updated as status is COMPLETED");
        }
      }
      if (
        (status === TASK_STATUS.COMPLETED || status === TASK_STATUS.VERIFIED) &&
        task.taskData.percentCompleted !== 100
      ) {
        if (req.body.percentCompleted !== 100) {
          return res.boom.badRequest("Status cannot be updated as progress of task is not 100%.");
        }
      }
    }

    const taskLog = {
      type: "task",
      meta: {
        userId,
        taskId,
        username,
      },
      body: {
        subType: "update",
        new: {},
      },
    };

    if (status && !req.body.percentCompleted) {
      taskLog.body.new.status = status;
    }
    if (req.body.percentCompleted && !status) {
      taskLog.body.new.percentCompleted = req.body.percentCompleted;
    }

    if (req.body.percentCompleted && status) {
      taskLog.body.new.percentCompleted = req.body.percentCompleted;
      taskLog.body.new.status = status;
    }

    const [, taskLogResult] = await Promise.all([
      tasks.updateTask(req.body, taskId),
      addLog(taskLog.type, taskLog.meta, taskLog.body),
    ]);
    taskLog.id = taskLogResult.id;

    if (status) {
      userStatusUpdate = await updateStatusOnTaskCompletion(userId);
    }
    return res.json({
      message: "Task updated successfully!",
      taskLog,
      ...(userStatusUpdate && { userStatus: userStatusUpdate }),
    });
  } catch (err) {
    logger.error(`Error while updating task status : ${err}`);
    return res.boom.badImplementation(INTERNAL_SERVER_ERROR);
  }
};

const transformTasksUsersQuery = (queries) => {
  if (!queries) return {};
  const { "days-count": dateGap, weekday, date, status, size } = queries;
  let transformedStatus;
  if (status && status.length === 1 && status[0].value) {
    transformedStatus = status[0].value;
  }
  let transformedSize;
  if (size) {
    transformedSize = Number.parseInt(size);
  }
  let transformedDateGap;
  if (dateGap && dateGap.length === 1) {
    transformedDateGap = Number.parseInt(dateGap[0].value);
  }
  let dateList;
  if (date) {
    dateList = date.map((date) => Number.parseInt(date.value));
  }
  let weekdayList;
  if (weekday) {
    weekdayList = weekday.map((day) => daysOfWeek[day.value]);
  }
  return { dateGap: transformedDateGap, status: transformedStatus, size: transformedSize, weekdayList, dateList };
};

const parseSearchQuery = (queryString) => {
  const searchParams = {};
  const queryParts = queryString.split("+");
  queryParts.forEach((part) => {
    const [key, value] = part.split(":");
    switch (key.toLowerCase()) {
      case "searchterm":
        searchParams.searchTerm = value.toLowerCase();
        break;
      case "assignee":
        searchParams.assignee = value.toLowerCase();
        break;
      case "status":
        searchParams.status = value.toLowerCase();
        break;
      default:
        break;
    }
  });
  return searchParams;
};

const updateTask = async (taskData, taskId = null) => {
  try {
    taskData = await toFirestoreData(taskData);
    if (taskId) {
      const task = await tasksModel.doc(taskId).get();
      if (taskData?.assignee && task.data().status === TASK_STATUS.AVAILABLE) {
        taskData = { ...taskData, status: TASK_STATUS.ASSIGNED };
      }
      if (taskData.status === "VERIFIED") {
        taskData = { ...taskData, endsOn: Math.floor(Date.now() / 1000) };
      }
      const { dependsOn, ...taskWithoutDependsOn } = taskData;
      await tasksModel.doc(taskId).set({
        ...task.data(),
        ...taskWithoutDependsOn,
      });
      if (dependsOn) {
        await firestore.runTransaction(async (transaction) => {
          const dependencyQuery = dependencyModel.where("taskId", "==", taskId);
          const existingDependenciesSnapshot = await transaction.get(dependencyQuery);
          const existingDependsOnIds = existingDependenciesSnapshot.docs.map((doc) => doc.data().dependsOn);
          const newDependencies = dependsOn.filter((dependency) => !existingDependsOnIds.includes(dependency));
          if (newDependencies.length > 0) {
            for (const dependency of newDependencies) {
              const dependencyDoc = await tasksModel.doc(dependency).get();
              if (dependencyDoc.exists) {
                const taskDependsOn = {
                  taskId: taskId,
                  dependsOn: dependency,
                };
                const docRef = dependencyModel.doc();
                transaction.set(docRef, taskDependsOn);
              } else {
                throw new Error("Invalid dependency passed");
              }
            }
          }
        });
      }
      return { taskId };
    }
    const taskInfo = await tasksModel.add(taskData);
    const result = {
      taskId: taskInfo.id,
      taskDetails: await fromFirestoreData(taskData),
    };
    return result;
  } catch (err) {
    logger.error("Error in updating task", err);
    throw err;
  }
};

const updateUserStatusOnTaskUpdate = async (userName) => {
  try {
    const userId = await getUserIdFromUserName(userName, usersCollection);
    const userStatusUpdate = await updateUserStatusOnNewTaskAssignment(userId);
    return userStatusUpdate;
  } catch (error) {
    if (error instanceof NotFound) {
      return {
        status: 404,
        error: "Not Found",
        message: error.message,
      };
    }
    return {
      status: 500,
      error: "Internal Server Error",
      message: error.message,
    };
  }
};

const updateStatusOnTaskCompletion = async (userId) => {
  try {
    const hasActiveTask = await checkIfUserHasLiveTasks(userId, tasksModel);
    const latestStatusData = await getUserStatus(userId);
    const { userStatusExists } = latestStatusData;
    if (!userStatusExists) {
      if (hasActiveTask) {
        return createUserStatusWithState(userId, userStatusModel, userState.ACTIVE);
      } else {
        await addGroupIdleRoleToDiscordUser(userId);
        return createUserStatusWithState(userId, userStatusModel, userState.IDLE);
      }
    }
    const {
      data: {
        currentStatus: { state },
      },
    } = latestStatusData;
    if (hasActiveTask) {
      switch (state) {
        case userState.OOO:
          return updateFutureStatusToState(userStatusModel, latestStatusData, userState.ACTIVE);
        case userState.ACTIVE:
          return generateAlreadyExistingStatusResponse(userState.ACTIVE);
        default:
          if (state === userState.IDLE) await removeGroupIdleRoleFromDiscordUser(userId);
          return updateCurrentStatusToState(userStatusModel, latestStatusData, userState.ACTIVE);
      }
    } else {
      switch (state) {
        case userState.OOO:
          return updateFutureStatusToState(userStatusModel, latestStatusData, userState.IDLE);
        case userState.IDLE:
          return generateAlreadyExistingStatusResponse(userState.IDLE);
        default:
          await addGroupIdleRoleToDiscordUser(userId);
          return updateCurrentStatusToState(userStatusModel, latestStatusData, userState.IDLE);
      }
    }
  } catch (error) {
    return generateErrorResponse(error.message);
  }
};

const transformQuery = (status = "", size, page, assignee = "", title = "") => {
  const query = {};
  const transformedStatus = MAPPED_TASK_STATUS[status.toUpperCase()];
  const transformedAssignee = assignee.toLowerCase();
  const transformedTitle = title;

  if (page) {
    query.page = parseInt(page);
  }

  if (size) {
    query.size = parseInt(size);
  }

  return {
    status: transformedStatus,
    assignee: transformedAssignee,
    title: transformedTitle,
    ...query,
  };
};